home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 008 / 68kgraph.arc / BITPRIM.ASM < prev    next >
Encoding:
Assembly Source File  |  1986-12-13  |  12.0 KB  |  351 lines
  1. ******************************************************************
  2. * COPYRIGHT (C) 1986 by Donald Krantz and James Stanley
  3. * - Note: This is a real, live, actual, registered copyright,
  4. *   and should be treated as such. This source code is from
  5. *   the book "68000 Assembly Language", Krantz and Stanley,
  6. *   Addison-Wesley Publishing Company, Reading, MA, 1986.
  7. * 
  8. *   Permission granted by the authors for non-commercial use
  9. *   in programs released to the public domain, as long as this
  10. *   copyright notice remains attached and visible.
  11. *
  12. *****************************************************************
  13. * BITPRIM - bit mapped graphics primitives
  14. #bit.h
  15.  
  16.     xref    image,sqrt
  17.     xdef    g_pix,g_mode,g_vector,g_circle,g_clear,g_fill
  18.     xdef    mode
  19.  
  20. *****************************************************************
  21. * SET_PIX - sets the pixel where D0.W = X and D1.W = Y
  22. g_pix:
  23.     movem.l    d0/d1/a0,-(a7)    * save caller's registers
  24. *
  25.     cmp.w    #hor_b,d0    * check clipping horizontal
  26.     bcc    sk0_sp        * exit on over X
  27.     cmp.w    #vert,d1    * check clipping vertical
  28.     bcc    sk0_sp        * exit on over Y
  29. *
  30.     move.l    #image,a0    * get base of image area
  31.     mulu    #(hor_w*2),d1    * get vertical offset to line
  32.     add.l    d1,a0        * and add to base address
  33.     move.w    d0,d1        * save X for later
  34.     lsr.w    #3,d0        * get number of bytes to pixel 
  35.     add.w    d0,a0        * add to pointer
  36.     and.w    #$0007,d1    * strip all but bit number
  37.     move.w    mode,d0        * get mode flag
  38.     lsr.w    #1,d0        * pop bit 0 into carry flag
  39.     bcs    sk1_sp        * jam mode jump
  40.     lsr.w    #1,d0        * pop bit 1 into carry flag
  41.     bcs    sk2_sp        * complement mode jump
  42.     lsr.w    #1,d0        * pop bit 2 into carry flag
  43.     bcs    sk3_sp        * set mode jump
  44.     bclr    d1,(a0)        * falls thru to clear mode
  45.     bra    sk0_sp        * so we're done
  46. sk1_sp:
  47. sk3_sp:
  48.     bset    d1,(a0)        * jam and set are the same here        
  49.     bra    sk0_sp        * now we're done
  50. sk2_sp:
  51.     bchg    d1,(a0)        * complement mode
  52. sk0_sp:
  53.     movem.l    (a7)+,d0/d1/a0    * restore caller's registers
  54.     rts
  55. *****************************************************************
  56. * SET_MODE - Sets mode to value contained in D0.W
  57. g_mode:
  58.     move.w    d0,mode
  59.     rts
  60. *****************************************************************
  61. * G_VECTOR - draws a vector from (D0.W,D1.W) to (D2.W,D3.W)
  62. g_vector:
  63.     movem.l    d0-d7,-(a7)    * Save registers
  64. ******* Scale and save vector origin coordinates ****************
  65.     move.w    d0,d4        * setup base for X
  66.     swap    d4        * scale x 2^16
  67.     clr.w    d4        * make even number
  68.     move.w    d1,d5        * setup base for Y
  69.     swap    d5        * scale x 2^16
  70.     clr.w    d5        * make even number
  71. ******* Determine absolute and signed run in X ******************
  72.     sub.w    d0,d2        * find difference in X
  73.     move.w    d2,d0        * save signed difference
  74.     bpl    sk1_vec        * skip X absolute value convert
  75.     neg.w    d0        * D0 is X absolute distance
  76. ******* Determine absolute and signed run in Y ******************
  77. sk1_vec:
  78.     sub.w    d1,d3        * find difference in Y
  79.     move.w    d3,d1        * save signed difference
  80.     bpl    sk2_vec        * skip Y absolute value convert
  81.     neg.w    d1        * D1 is Y absolute distance
  82. ******* Determine independent (larger) and dependent axis *******
  83. sk2_vec:
  84.     cmp.w    d0,d1        * see if X dif > Y dif
  85.     bgt    Y_bigger    * jump if y is bigger
  86. ******* X is independent axis - determine X step as +/- 1.0 *****
  87.     tst.w    d2        * check sign of X run
  88.     bmi    sk3_vec        * jump if negative
  89.     move.l    #$00010000,d6    * setup X step = 1.0
  90.     bra    sk4_vec        * jump to Y setup
  91. sk3_vec:
  92.     move.l    #$FFFF0000,d6    * setup Y step = -1.0
  93. ******* Determine Y step as scaled fixed point longword *********
  94. sk4_vec:
  95.     swap    d3        * Scale up 
  96.     clr.w    d3        * make longword
  97.     asr.l    #2,d3        * take out two bits of precision
  98.     divs    d0,d3        * divide by independent axis
  99.     ext.l    d3        * make long again
  100.     asl.l    #2,d3        * put two precisions bits back
  101.     move.l    d3,d7        * D7 is signed Y step
  102.     move.w    d0,d2        * get independant axis counter
  103.     bra    sk7_vec        * go do output
  104. ******* Y is independent axis - setup Y step as +/- 1.0 *********
  105. Y_bigger:
  106.     tst.w    d3        * check sign of Y run
  107.     bmi    sk5_vec        * jump if step negative
  108.     move.l    #$00010000,d7    * make Y step 1.0
  109.     bra    sk6_vec        * jump to X setup
  110. sk5_vec:
  111.     move.l    #$FFFF0000,d7    * make Y step -1.0
  112. ******* Determine X step as scaled fixed point longword *********
  113. sk6_vec:
  114.     swap    d2        * Scale up 
  115.     clr.w    d2        * make longword
  116.     asr.l    #2,d2        * Take out two bits of precision
  117.     divs    d1,d2        * divide by independent axis
  118.     ext.l    d2        * make long again
  119.     asl.l    #2,d2        * put back the precision
  120.     move.l    d2,d6        * D6 is signed X step
  121.     move.w    d1,d2        * get independant axis counter
  122. *
  123. ******* Pixel output loop ***************************************
  124. sk7_vec:
  125.     bra    sk8_vec        * do loop test before body
  126. lp0_vec:
  127.     move.l    d4,d0        * get scaled X position
  128.     add.l    #$00008000,d0    * round up by adding 0.5
  129.     swap    d0        * scale X down for output
  130.     move.l    d5,d1        * get scaled Y position
  131.     add.l    #$00008000,d1    * round up by adding 0.5
  132.     swap    d1        * scale Y down for output
  133.     bsr    g_pix        * put the pixel
  134.     add.l    d6,d4        * add X step
  135.     add.l    d7,d5        * add Y step
  136. sk8_vec:
  137.     dbra    d2,lp0_vec    * loop around
  138.     movem.l    (a7)+,d0-d7    * restore registers
  139.     rts
  140. *****************************************************************
  141. * Draws a circle around (D0.W,D1.W) of radius D2.W
  142. g_circle:
  143.     movem.l    d0-d7,-(a7)    * Save registers
  144.     move.w    d0,d6        * d6 will be X base pixel
  145.     move.w    d1,d7        * d7 will be Y base pixel
  146.     move.w    d2,d3        * get copy of radius
  147.     mulu    d3,d3        * d3.l is radius squared
  148.     swap    d2        * make into scaled longword
  149.     clr.w    d2        * truncate  
  150.     divu    #$B504,d2    * radius / (sqr(2) << 15)
  151.     add.w    #1,d2        * round up
  152.     asr.l    #1,d2        * align D2 because sqr(2) scaled  
  153. lp0_cir:
  154.     move.w    d2,d4        * d4 is a scratch register
  155.     mulu    d4,d4        * d4 is (rise**2)
  156.     move.l    d3,d0        * d0 is  scratch register
  157.     sub.l    d4,d0        * d0 is (run**2) 
  158.     bsr    sqrt        * after call, d0 = (run)
  159.     move.w    d0,d4        * save run
  160. ******* Quadrant I, counterclockwise
  161.     move.w    d6,d0        * X center
  162.     move.w    d7,d1        * Y center
  163.     add.w    d4,d0        * add run
  164.     add.w    d2,d1        * add rise
  165.     bsr    g_pix
  166. ******* Quadrant I, clockwise
  167.     move.w    d6,d0        * X center
  168.     move.w    d7,d1        * Y center
  169.     add.w    d4,d1        * add rise
  170.     add.w    d2,d0        * add run
  171.     bsr    g_pix
  172. ******* Quadrant II, counterclockwise
  173.     move.w    d6,d0        * X center
  174.     move.w    d7,d1        * Y center
  175.     sub.w    d2,d0        * add rise
  176.     add.w    d4,d1        * add run
  177.     bsr    g_pix
  178. ******* Quadrant II, clockwise
  179.     move.w    d6,d0        * X center
  180.     move.w    d7,d1        * Y center
  181.     add.w    d2,d1        * add rise
  182.     sub.w    d4,d0        * add run
  183.     bsr    g_pix
  184. ******* Quadrant III, counterclockwise
  185.     move.w    d6,d0        * X center
  186.     move.w    d7,d1        * Y center
  187.     sub.w    d2,d1        * add rise
  188.     sub.w    d4,d0        * add run
  189.     bsr    g_pix
  190. ******* Quadrant III, clockwise
  191.     move.w    d6,d0        * X center
  192.     move.w    d7,d1        * Y center
  193.     sub.w    d2,d0        * add rise
  194.     sub.w    d4,d1        * add run
  195.     bsr    g_pix
  196. ******* Quadrant IV, counterclockwise
  197.     move.w    d6,d0        * X center
  198.     move.w    d7,d1        * Y center
  199.     add.w    d2,d0        * add rise
  200.     sub.w    d4,d1        * add run
  201.     bsr    g_pix
  202. ******* Quadrant IV, clockwise
  203.     move.w    d6,d0        * X center
  204.     move.w    d7,d1        * Y center
  205.     add.w    d4,d0        * add run
  206.     sub.w    d2,d1        * add rise
  207.     bsr    g_pix
  208.     dbra    d2,lp0_cir    * loop for next set 
  209.     movem.l    (a7)+,d0-d7    * Restore registers
  210.     rts
  211. *****************************************************************
  212. * Clears the graphics image area
  213. g_clear:
  214.     movem.l    a0/d0,-(a7)    * save registers
  215.     move.l    #image,a0    * Get image area base address
  216.     move.l    #(vert*hor_w/2),d0
  217. lp0_cl:
  218.     clr.l    (a0)+        * zero out byte
  219.     subq.l    #1,d0        * pop counter
  220.     bne    lp0_cl        * loop for next
  221.     movem.l    (a7)+,a0/d0    * restore registers
  222.     rts
  223. *****************************************************************
  224. * Fills the area bounded by (D0.W,D1.W) and (D2.W,D3.W)
  225. g_fill:
  226.     movem.l    d0-d7/a0/a1,-(a7) save callers registers
  227. ******* Adjust so that D2.W >= D0.W and D3.W >= D1.W
  228.     cmp.w    d0,d2        * Who's bigger?
  229.     bge    sk1_fil        * jump if d2 is bigger
  230.     exg    d0,d2        * swap if not
  231. sk1_fil:
  232.     cmp.w    d1,d3        * Who's bigger here?
  233.     bge    sk2_fil        * jump if d3 is bigger
  234.     exg    d1,d3        * swap if not
  235. sk2_fil:
  236. ******* Calculate (number of rows) - 1, save in D7
  237.     move.w    d3,d7        * uses D7 as accumulator
  238.     sub.w    d1,d7        * D7 is (#rows-1)
  239. ******* Calculate first byte address in A0
  240.     move.l    #image,a0    * A0 is base of image memory     
  241.     mulu    #(hor_w*2),d1    * D1 is row offset from zero
  242.     move.w    d0,d3        * D3 is a scratch register
  243.     asr.w    #3,d3        * D3 is number of bytes into row
  244.     add.w    d3,d1        * D1 is bytes into image
  245.     add.w    d1,a0        * A0 is now address of first byte
  246. ******* Make mask for left fragment in D4.B
  247.     move.w    d0,d1        * D1 is scratch register
  248.     and.w    #$0007,d1    * D1 is pixel address
  249.     move.w    #$00FF,d4    * D4 will be fragment mask
  250.     lsl.b    d1,d4        * move mask to correct pixels
  251. ******* Make mask for right fragment in D6.B
  252.     move.w    d2,d1        * D1 is scratch register
  253.     and.w    #$07,d1        * D1 is pixel address
  254.     move.w    #$FE01,d6    * D6 will be fragment mask
  255.     rol.w    d1,d6        * move mask to correct pixels
  256. ******* Compute distance 'twixt start and end byte in row 
  257.     lsr.w    #3,d0        * get starting offset into row
  258.     lsr.w    #3,d2        * get ending offset into row
  259. ******* Test for special case - left and right frags in same byte
  260.     sub.w    d0,d2        * are they the same?
  261.     bne    sk3_fil        * jump if not...
  262. ******* process start/end in same byte
  263.     and.b    d6,d4        * combine the two masks
  264.     btst    #0,mode+1    * look for jam mode
  265.     bne    sk4_fil        * go jam
  266.     btst    #1,mode+1    * look for complement mode
  267.     bne    sk5_fil        * go complement
  268.     btst    #2,mode+1    * look for set mode
  269.     bne    sk4_fil        * it's the same as jam here
  270. ******* must be clear mode, special case. Let's do it! (yay!) ***
  271.     not.b    d4        * invert the mask
  272. lp1_fil:
  273.     and.b    d4,(a0)        * reset the right bits
  274.     add.l    #(hor_w*2),a0    * move the address to next row
  275.     dbra    d7,lp1_fil    * and repeat as necessary
  276.     bra    ex_fill        * finished!
  277. ******* jam or set mode, special case ***************************
  278. sk4_fil:
  279.     or.b    d4,(a0)        * set the right bits
  280.     add.l    #(hor_w*2),a0    * move the address to next row
  281.     dbra    d7,sk4_fil    * and repeat
  282.     bra    ex_fill        * exit
  283. ******* complement mode, special case ***************************
  284. sk5_fil:
  285.     eor.b    d4,(a0)        * complement the right bits
  286.     add.l    #(hor_w*2),a0    * move the address to next row
  287.     dbra    d7,sk4_fil    * repeat
  288.     bra    ex_fill        * exit
  289. ******* normal (multi-byte/row) fill case continued *************
  290. sk3_fil:
  291.     subq.w    #1,d2        * d2 is now number of whole bytes
  292.     btst    #0,mode+1    * look for jam mode
  293.     bne    sk6_fil        * go jam
  294.     btst    #1,mode+1    * look for complement mode
  295.     bne    sk7_fil        * go complement
  296.     btst    #2,mode+1    * look for set mode
  297.     bne    sk6_fil        * it's the same as jam here
  298. ******* Must be clear mode, normal case *************************
  299.     not.b    d4        * invert start mask
  300.     not.b    d6        * invert end mask
  301. lp2_fil:
  302.     move.w    d2,d5        * Have to save d2 
  303.     move.l    a0,a1        * A1 can be modified, A0 can't.
  304.     and.b    d4,(a1)+    * catch left-hand bits
  305.     bra    sk8_fil        * do loop test before body
  306. lp3_fil:
  307.     clr.b    (a1)+        * zero out middle bytes     
  308. sk8_fil:
  309.     dbra    d5,lp3_fil    * repeat for middle bytes
  310.     and.b    d6,(a1)        * get right-hand bits
  311.     add.l    #(hor_w*2),a0    * move to next row
  312.     dbra    d7,lp2_fil    * repeat for all rows
  313.     bra    ex_fill        * and quit
  314. ******* Jam or Set mode, normal case ****************************
  315. sk6_fil:
  316.     move.w    d2,d5        * Have to save d2 
  317.     move.l    a0,a1        * A1 can be modified, A0 can't.
  318.     or.b    d4,(a1)+    * catch left-hand bits
  319.     bra    sk9_fil        * do loop test before body
  320. lp4_fil:
  321.     move.b    #$FF,(a1)+    * set middle bytes     
  322. sk9_fil:
  323.     dbra    d5,lp4_fil    * repeat for middle bytes
  324.     or.b    d6,(a1)        * get right-hand bits
  325.     add.l    #(hor_w*2),a0    * move to next row
  326.     dbra    d7,sk6_fil    * repeat for all rows
  327.     bra    ex_fill        * and quit
  328. ******* Complement mode, normal case ****************************
  329. sk7_fil:
  330.     move.w    d2,d5        * Have to save d2 
  331.     move.l    a0,a1        * A1 can be modified, A0 can't.
  332.     eor.b    d4,(a1)+    * catch left-hand bits
  333.     bra    sk10_fil    * do loop test before body
  334. lp5_fil:
  335.     eor.b    #$FF,(a1)+    * zero out middle bytes     
  336. sk10_fil:
  337.     dbra    d5,lp5_fil    * repeat for middle bytes
  338.     eor.b    d6,(a1)        * get right-hand bits
  339.     add.l    #(hor_w*2),a0    * move to next row
  340.     dbra    d7,sk7_fil    * repeat for all rows
  341. ******* fill procedure common exit ******************************
  342. ex_fill:
  343.     movem.l    (a7)+,d0-d7/a0/a1 restore registers
  344.     rts
  345. *****************************************************************
  346.  
  347.     data
  348. mode    dc.w    jam_m        * start in jam mode
  349.  
  350.     end
  351.